home *** CD-ROM | disk | FTP | other *** search
/ World of Education / World of Education.iso / world_x / xcoral16.zip / BROWSER_.C < prev    next >
C/C++ Source or Header  |  1993-01-15  |  15KB  |  567 lines
  1. /*
  2. ** Copyright 1989, 1992 by Lionel Fournigault
  3. **
  4. ** Permission to use, copy, and distribute for non-commercial purposes,
  5. ** is hereby granted without fee, providing that the above copyright
  6. ** notice appear in all copies and that both the copyright notice and this
  7. ** permission notice appear in supporting documentation.
  8. ** The software may be modified for your own purposes, but modified versions
  9. ** may not be distributed.
  10. ** This software is provided "as is" without any expressed or implied warranty.
  11. **
  12. **
  13. */
  14.  
  15. #include "result_types.h"
  16. #include "file_dict.h"
  17. #include "proc_dict.h"
  18. #include "class_dict.h"
  19. #include "browser_engine.h"
  20. #include "browser_parse.h"
  21. #include "browser_util.h"
  22. #include <string.h>
  23. #include <stdio.h>
  24.  
  25.  
  26. /*------------------------------------------------------------------------------
  27. */
  28. StringTable* get_files_list () {
  29.   FileRec*     current_file;
  30.   StringTable* result;
  31.   char**       current_entry;
  32.   int          index;
  33.   int          x_size;
  34.  
  35.   x_size = sizeof(char*) * (file_count + 1);
  36.   result = (StringTable*) xmalloc(x_size);
  37.   if (result != Null) {
  38.     current_entry = (char**) result;
  39.     for (index = 0; index < FILE_DICT_SIZE; index++) {
  40.       current_file = file_dict[index];
  41.       while(current_file != Null) {
  42.         (*current_entry) = current_file->_name;
  43.         current_entry++;
  44.         current_file = current_file->_next;
  45.       }
  46.     }
  47.     (*current_entry) = Null;
  48.     qsort(result, file_count, sizeof(char*), sort_util);
  49.   }
  50.   return(result);
  51. }
  52.  
  53.  
  54. /*------------------------------------------------------------------------------
  55. */
  56. StringTable* get_classes_list () {
  57.   ClassRec*    current_class;
  58.   StringTable* result;
  59.   char**       current_entry;
  60.   int          index;
  61.   int          x_size;
  62.   char*        infos;
  63.  
  64.   x_size = sizeof(char*) * (class_count + 1);
  65.   result = (StringTable*) xmalloc(x_size);
  66.   if (result != Null) {
  67.     current_entry = (char**) result;
  68.     for (index = 0; index < CLASS_DICT_SIZE; index++) {
  69.       current_class = class_dict[index];
  70.       while(current_class != Null) {
  71.         (*current_entry) = current_class->_name;
  72.         infos = (*current_entry) - CLASS_PLENGTH + 1;
  73.         if (current_class->_decl_file != Null)
  74.           *infos = 'd';
  75.         else
  76.           *infos = '?';
  77.         current_entry++;
  78.         current_class = current_class->_next;
  79.       }
  80.     }
  81.     (*current_entry) = Null;
  82.     qsort(result, class_count, sizeof(char*), sort_util);
  83.   }
  84.   return(result);
  85. }
  86.  
  87.  
  88. /*------------------------------------------------------------------------------
  89. */
  90. StringTable* get_parents_list (class_name)
  91.      char* class_name;
  92. {
  93.   StringTable* result;
  94.   char**       current_entry;
  95.   ClassRec*    current_class;
  96.   ClassRec*    parent_class;
  97.   ParentRec*   current_parent;
  98.   int          x_size;
  99.   char*        infos;
  100.  
  101.   result = Null; 
  102.   current_class = find_class(class_name);
  103.   if (current_class != Null) {
  104.     x_size = sizeof(char*) * (current_class->_parents_count + 1);
  105.     result = (StringTable*) xmalloc(x_size);
  106.     if (result != Null) {
  107.       current_entry  = (char**) result;
  108.       current_parent = current_class->_parents_list;
  109.       while (current_parent != Null) {
  110.         (*current_entry) = current_parent->_name;
  111.         infos = (*current_entry) - PARENT_PLENGTH + 1;
  112.         parent_class = find_class(*current_entry);
  113.         if ((parent_class != Null) && (parent_class->_decl_file != Null))
  114.           *infos = 'd';
  115.         else
  116.           *infos = '?';
  117.         current_entry++;
  118.         current_parent = current_parent->_next;
  119.       }
  120.       (*current_entry) = Null;
  121.       qsort(result, current_class->_parents_count, sizeof(char*), sort_util);
  122.     }
  123.   }
  124.   return(result);
  125. }
  126.  
  127.  
  128. /*------------------------------------------------------------------------------
  129. */
  130. StringTable* get_sons_list(class_name)
  131.     char* class_name;
  132. {
  133.   int          index;
  134.   int          marked_count;
  135.   ClassRec*    marked_list;
  136.   ClassRec*    current_class;
  137.   ParentRec*   current_parent;
  138.   StringTable* result;
  139.   char**       current_entry;
  140.   int          x_size;
  141.   char*        infos;
  142.  
  143.   marked_list  = Null;
  144.   marked_count = 0;
  145.   for (index = 0; index < CLASS_DICT_SIZE; index++) {
  146.     current_class = class_dict[index];
  147.     while (current_class != Null) {
  148.       current_parent = current_class->_parents_list;
  149.       while (current_parent != Null) {
  150.         if (strcmp(current_parent->_name, class_name) == 0) {
  151.           current_class->_next_marked = marked_list;
  152.           marked_list                 = current_class;
  153.           marked_count++;
  154.         }
  155.         current_parent = current_parent->_next;
  156.       }
  157.       current_class = current_class->_next;
  158.     }
  159.   }
  160.   x_size = sizeof(char*) * (marked_count + 1);
  161.   result = (StringTable*) xmalloc(x_size);
  162.   if (result != Null) {
  163.     current_entry = (char**) result;
  164.     while (marked_list != Null) {
  165.       (*current_entry) = marked_list->_name;
  166.       infos = (*current_entry) - CLASS_PLENGTH + 1;
  167.       if (marked_list->_decl_file != Null)
  168.         *infos = 'd';
  169.       else
  170.         *infos = '?';
  171.       current_entry++;
  172.       marked_list = marked_list->_next_marked;
  173.     }
  174.     (*current_entry) = Null;
  175.     qsort(result, marked_count, sizeof(char*), sort_util);
  176.   }
  177.   return(result);
  178. }
  179.  
  180.  
  181. /*------------------------------------------------------------------------------
  182. */
  183. static MethodRec* marked_list;
  184. static int        marked_count;
  185.  
  186. #define END_MARKED_LIST ((MethodRec*) 0x00000001)
  187.  
  188.  
  189. int sort_method(i,j)
  190.   char** i;
  191.   char** j;
  192. {
  193.   char* ti = *i;
  194.   char* tj = *j;
  195.   char* par_posit;
  196.   int   result;
  197.  
  198.   if ((**i) == '~')
  199.     ti = (*i) + 1;
  200.   if ((**j) == '~')
  201.     tj = (*j) + 1;
  202.   par_posit = strchr(ti, '(');
  203.   result    = strncmp(ti, tj, (par_posit - ti));
  204.   if (result == 0) {
  205.     if ((**i) == '~')
  206.       result = 1;
  207.     else if ((**j) == '~')
  208.       result = -1;
  209.     else {
  210.       result = strcmp(*i, *j);
  211.       if (result == 0) {
  212.         if (*((*i) - METHOD_PLENGTH + 2) > *((*j) - METHOD_PLENGTH + 2))
  213.           result = -1;
  214.         else
  215.           result = 1;
  216.       }
  217.     }
  218.   }
  219.   return(result);
  220. }
  221.  
  222.  
  223. void post_compute(result)
  224.     StringTable* result;
  225. {
  226.   char**  current_entry;
  227.   char*   current_depth;
  228.   char*   infos;
  229.   char*   virtual_method_name = "";
  230.   int     virtual_flag;
  231.  
  232.   virtual_flag  = False;
  233.   current_entry = (char**) result;
  234.   while ((*current_entry) != Null) {
  235.     infos = (*current_entry) - METHOD_PLENGTH + 1;
  236.     if ((*infos) == 'V') {
  237.       if (strcmp(virtual_method_name, (*current_entry)) == 0)
  238.         (*infos) = 'v';
  239.       else {
  240.         virtual_flag        = True;
  241.         virtual_method_name = (*current_entry);
  242.       }
  243.     }
  244.     else if (virtual_flag == True) {
  245.       if (strcmp(virtual_method_name, (*current_entry)) == 0)
  246.         (*infos) = 'v';
  247.       else
  248.         virtual_flag = False;
  249.     }
  250.     current_depth = infos + 1;
  251.     if ((*current_depth) == 0)
  252.       (*current_depth) = 'L';
  253.     else {
  254.       (*current_depth) = '0' + (*current_depth);
  255.       (*current_depth) = (((*current_depth) <= '9') ? (*current_depth) : '9');
  256.     }
  257.     current_entry++;
  258.   }
  259. }
  260.  
  261.  
  262. void get_inherit_list(current_class, max_scope, depth)
  263.      ClassRec* current_class;
  264.      ScopeType max_scope;
  265.      int       depth;
  266. {
  267.   MethodRec*  current_method;
  268.   ParentRec*  current_parent;
  269.  
  270.   current_method = current_class->_methods_list;
  271.   while(current_method != Null) {
  272.     if (   (current_method->_scope <= max_scope)
  273.         && (current_method->_next_marked == Null)) {
  274.       *(current_method->_name - METHOD_PLENGTH + 2) = depth;
  275.       current_method->_next_marked = marked_list;
  276.       marked_list                  = current_method;
  277.       marked_count++;
  278.     }
  279.     current_method = current_method->_next;
  280.   }
  281.   current_parent = current_class->_parents_list;
  282.   while (current_parent != Null) {
  283.     if (depth < 255)
  284.       depth++;
  285.     if (current_parent->_scope < PRIVATE_SCOPE) {
  286.         current_class = find_class(current_parent->_name);
  287.         if (current_class != Null)
  288.           get_inherit_list(current_class, PROTECTED_SCOPE, depth);
  289.     }
  290.     current_parent = current_parent->_next;
  291.   }
  292. }
  293.  
  294.  
  295. StringTable* get_methods_list(class_name)
  296.     char* class_name;
  297. {
  298.   ClassRec*    current_class;
  299.   MethodRec*   current_method;
  300.   StringTable* result;
  301.   char**       current_entry;
  302.   int          x_size;
  303.   char*        infos;
  304.  
  305.   result        = Null;
  306.   marked_list   = END_MARKED_LIST;
  307.   marked_count  = 0;
  308.   current_class = find_class(class_name);
  309.   if (current_class != Null) {
  310.     get_inherit_list(current_class, PRIVATE_SCOPE, 0);
  311.     if (marked_list != END_MARKED_LIST)  {
  312.       x_size = sizeof(char*) * (marked_count + 1);
  313.       result = (StringTable*) xmalloc(x_size);
  314.       if (result != Null) {
  315.         current_entry  = (char**) result;
  316.         current_method = marked_list;
  317.         while(current_method != END_MARKED_LIST) {
  318.           (*current_entry) = current_method->_name;
  319.           infos = (*current_entry) - METHOD_PLENGTH + 1;
  320.           if (current_method->_decl_file != Null)
  321.             *(infos + 2) = 'd';
  322.           else
  323.             *(infos + 2) = '?';
  324.           if (current_method->_impl_file != Null)
  325.             *(infos + 3) = 'i';
  326.           else
  327.             *(infos + 3) = '?';
  328.           if (strncmp(current_method->_class_name, 
  329.                       current_method->_name,
  330.                       strlen(current_method->_class_name)) == 0)
  331.             *infos = 'c';
  332.           else if ((*(current_method->_name)) == '~')
  333.             *infos = 'd';
  334.           else if (current_method->_virtual_decl == True)
  335.             *infos = 'V';
  336.           else
  337.             *infos = ' ';
  338.           current_entry++;
  339.           marked_list = marked_list->_next_marked;
  340.           current_method->_next_marked = Null;
  341.           current_method = marked_list;
  342.         }
  343.         (*current_entry) = Null;
  344.         qsort(result, marked_count, sizeof(char*), sort_method);
  345.         post_compute(result);
  346.       }
  347.     }
  348.   }
  349.   return(result);
  350. }
  351.  
  352.  
  353. /*------------------------------------------------------------------------------
  354. */
  355. Position* get_class_decl (class_name)
  356.     char* class_name;
  357. {
  358.   Position*     result;
  359.   ClassRec*     current_class;
  360.   int           x_size;
  361.  
  362.   result = Null;
  363.   current_class = find_class(class_name);
  364.   x_size = sizeof(Position);
  365.   if (   (current_class != Null)
  366.       && (current_class->_decl_file != Null)
  367.       && ((result = (Position*) xmalloc(x_size)) != Null)) {
  368.     result->file_name   = current_class->_decl_file->_name;
  369.     result->line_number = current_class->_decl_line;
  370.   }
  371.   return(result);
  372. }
  373.  
  374.  
  375. /*------------------------------------------------------------------------------
  376. */
  377. char* get_method_class(method_name)
  378.     char* method_name;
  379. {
  380.   MethodRec* current_method;
  381.   int        x_size;
  382.  
  383.   x_size = sizeof(MethodRec);
  384.   current_method = (MethodRec*) (method_name - x_size - METHOD_PLENGTH);
  385.   return(current_method->_class_name);
  386. }
  387.  
  388.   
  389. /*------------------------------------------------------------------------------
  390. */
  391. Position* get_method_decl (class_name, method_name)
  392.     char* class_name;
  393.     char* method_name;
  394. {
  395.   Position*     result;
  396.   ClassRec*     current_class;
  397.   MethodRec*    current_method;
  398.   int           x_size;
  399.   
  400.   result = Null;
  401.   current_class = find_class(class_name);
  402.   if (current_class != Null) {
  403.     current_method = current_class->_methods_list;
  404.     while (current_method != Null) {
  405.       if (strcmp(current_method->_name, method_name) == 0)
  406.         break;
  407.       current_method = current_method->_next;
  408.     }
  409.     x_size = sizeof(Position);
  410.     if (   (current_method != Null)
  411.         && (current_method->_decl_file != Null)
  412.         && ((result = (Position*) xmalloc(x_size)) != Null)) {
  413.       result->file_name   = current_method->_decl_file->_name;
  414.       result->line_number = current_method->_decl_line;
  415.     }
  416.   }
  417.   return(result);
  418. }
  419.  
  420.  
  421. /*------------------------------------------------------------------------------
  422. */
  423. Position* get_method_impl (class_name, method_name)
  424.      char* class_name;
  425.      char* method_name;
  426. {
  427.   Position*     result;
  428.   ClassRec*     current_class;
  429.   MethodRec*    current_method;
  430.   int           x_size;
  431.  
  432.   result = Null;
  433.   current_class = find_class(class_name);
  434.   if (current_class != Null) {
  435.     current_method = current_class->_methods_list;
  436.     while (current_method != Null) {
  437.       if (strcmp(current_method->_name, method_name) == 0)
  438.         break;
  439.       current_method = current_method->_next;
  440.     }
  441.     x_size = sizeof(Position);
  442.     if (   (current_method != Null)
  443.         && (current_method->_impl_file != Null)
  444.         && ((result = (Position*) xmalloc(x_size)) != Null)) {
  445.       result->file_name   = current_method->_impl_file->_name;
  446.       result->line_number = current_method->_impl_line;
  447.     }
  448.   }
  449.   return(result);
  450. }
  451.  
  452.  
  453. /*------------------------------------------------------------------------------
  454. */
  455. StringTable* get_procs_list () {
  456.   ProcRec*     current_proc;
  457.   StringTable* result;
  458.   char**       current_entry;
  459.   int          index;
  460.   int          x_size;
  461.   char*        infos;
  462.  
  463.   x_size = sizeof(char*) * (proc_count + 1);
  464.   result = (StringTable*) xmalloc(x_size);
  465.   if (result != Null) {
  466.     current_entry = (char**) result;
  467.     for (index = 0; index < PROC_DICT_SIZE; index++) {
  468.       current_proc = proc_dict[index];
  469.       while(current_proc != Null) {
  470.         (*current_entry) = current_proc->_name;
  471.         infos = (*current_entry) - PROC_PLENGTH + 1;
  472.         switch (current_proc->_proc_type) {
  473.           case CPLUS_PROC :
  474.             *(infos + 1) = '+';
  475.             *(infos + 2) = '+';
  476.           case C_PROC :
  477.             *infos = 'c';
  478.             break;
  479.           default :
  480.             *infos = '?';
  481.         }
  482.         current_entry++;
  483.         current_proc = current_proc->_next;
  484.       }
  485.     }
  486.     (*current_entry) = Null;
  487.     qsort(result, proc_count, sizeof(char*), sort_util);
  488.   }
  489.   return(result);
  490. }
  491.  
  492.  
  493. /*------------------------------------------------------------------------------
  494. */
  495. Position* get_proc_impl (proc_name)
  496.     char* proc_name;
  497. {
  498.   Position*     result;
  499.   ProcRec*      current_proc;
  500.   int           x_size;
  501.  
  502.   result = Null;
  503.   current_proc = find_proc(proc_name);
  504.   x_size = sizeof(Position);
  505.   if (   (current_proc != Null)
  506.       && (current_proc->_impl_file != Null)
  507.       && ((result = (Position*) xmalloc(x_size)) != Null)) {
  508.     result->file_name   = current_proc->_impl_file->_name;
  509.     result->line_number = current_proc->_impl_line;
  510.   }
  511.   return(result);
  512. }
  513.  
  514.  
  515. /*------------------------------------------------------------------------------
  516. */
  517. void parse_file(file_name)
  518.      char* file_name;
  519. {
  520.   parsed_file = find_file(file_name);
  521.   if (parsed_file != Null) {
  522.     proc_eraze_file(file_name);
  523.     class_eraze_file(file_name);
  524.   }
  525.   else
  526.     parsed_file = create_file(file_name);
  527.   if (parsed_file != Null) {
  528.     if (browser_yyparse(file_name) == 1) {
  529.       fprintf(stderr, "    >>  file \"%s\" will be ignored\n\n", file_name);
  530.       proc_eraze_file(file_name);
  531.       class_eraze_file(file_name);
  532.       remove_file(file_name);
  533.     }
  534.     garbage_proc();
  535.     garbage_class();
  536.   }
  537.   parsed_file = Null;
  538.   class_cache = Null;
  539. }
  540.  
  541.  
  542. /*------------------------------------------------------------------------------
  543. */
  544. void delete_file(file_name)
  545.      char* file_name;
  546. {
  547.   FileRec* current_file;
  548.  
  549.   current_file = find_file(file_name);
  550.   if (current_file != Null) {
  551.     proc_eraze_file(file_name);
  552.     class_eraze_file(file_name);
  553.     garbage_proc();
  554.     garbage_class();
  555.   }
  556.   remove_file(file_name);
  557. }
  558.  
  559.  
  560. /*------------------------------------------------------------------------------
  561. */
  562. void init_browser() {
  563.   init_file();
  564.   init_proc();
  565.   init_class();
  566. }
  567.